package untitled.src.com.mtwo.work;

import java.util.Scanner;

public class WorkTwo {
    //定义常量用于记录黑棋，不可修改
    private final static String BLACK = "黑";
    //定义常量用于记录白棋，不可修改
    private final static String WHTIE = "白";
    //表示行
    private int line;
    //表示列
    private int column;
    //用于记录棋子
    private String gobang;


    //定义二维数组描述棋盘,且用于保存黑棋和白棋
    private String[][] theBoard = new String[16][16];

    //1、绘制棋盘 - 写一个成员方法实现 （参数1为行，参数2为列，参数3为记录棋子的值）
    public void gobangBoard(int line, int column, String gobang) {
        this.gobang = gobang;
        //将当前棋子的值赋给所输入的行列所对应的坐标存入theBoard数组
        theBoard[line][column] = this.gobang;
        //使用for循环实现棋盘第一行信息
        for (int i = 0; i < 17; i++) {
            //如果i等于0则打印一个空格，绘制棋盘
            if (0 == i) {
                System.out.print("\t");
            } else {
                // 按照十六进制的格式打印i-1的数值
                System.out.printf("%x\t", i - 1);
            }
        }
        System.out.println();
        //使用双重for循环打印棋盘
        for (int i = 0; i < theBoard.length; i++) {
            // 按照十六进制的格式打印i-1的数值
            System.out.printf("%x\t", i);
            for (int j = 0; j < theBoard[i].length; j++) {
                //如果此时数组中的值为空则打印+加空格，绘制棋盘，此时数组对应的坐标不为空时将该值打印
                if (null == theBoard[i][j]) {
                    System.out.print("+\t");
                } else {
                    //打印theBoard[i][j]坐标所对应的值
                    System.out.print(theBoard[i][j] + "\t");
                }
            }
            System.out.println();
        }


    }

    //2、提示黑方和白方分别下棋并重新绘制棋盘 - 写一个成员方法实现
    public void play() {
        //定义一个变量用于区分黑和白，true为黑，false为白
        boolean flag = true;
        //定义Scanner对象，用于从控制台输入
        Scanner scanner = new Scanner(System.in);
        //使用无限循环模拟下棋
        for (; ; ) {
            //使用三目运算符判断实现黑方和白方交替下棋，true为黑方，false为白方
            System.out.println((flag ? BLACK : WHTIE) + "方下棋:");
            System.out.print("请输入行（0-15）【55退出游戏】：");
            //提示用户从控制台输入，使用line变量存储，表示行
            this.line = scanner.nextInt();
            System.out.print("请输入列（0-15）【55退出游戏】：");
            ////提示用户从控制台输入，使用column变量存储，表示列
            this.column = scanner.nextInt();
            //判断如果用户输入55，则循环结束
            if (55 == this.line || 55 == this.column) {
                System.out.println("游戏结束");
                break;
                //判断如果行小于0或者大于等于16或者列小于0或者大于=16则提示输入错误，防止数组越界
            } else if (line < 0 || line >= 16 || column < 0 || column >= 16) {
                System.out.println("您输入的位置有误，请重新输入");
                //判断如果此时数组对应的坐标不为null时，证明该位置已有值，提示用户重新输入
            } else if (theBoard[line][column] != null) {
                System.out.println("该位置以下，请重新输入");
            } else {
                //打印输出此时黑方/白方下棋的位置
                System.out.println((flag ? BLACK : WHTIE) + "方下的位置为：" + line + "行，" + column + "列");
                //调用gobangBoard方法（棋盘方法），且传入参数 行 列 黑棋/白棋
                gobangBoard(line, column, (flag ? BLACK : WHTIE));
                //声明w变量用于记录ending方法返回的值，
                //调用ending方法，并传参数 true/false 行 列
                boolean w = ending(flag, line, column);
                //判断如果w为true时游戏结束，终止循环
                if (true == w) {
                    System.out.println("游戏结束");
                    break;
                }
                //使用非运算符，实现如果flag为true时，则赋值false给flag
                flag = !flag;
            }

        }
    }

    //3、每当一方下棋后判断是否获胜
    //定义ending方法，下棋后判断是否获胜 （参数1：接受flag值黑棋为true，白为false  参数2 行 参数3 列）
    public boolean ending(boolean judge, int line, int column) {
        //声明变量用于记录棋子连续的总数
        int num = 0;
        //声明变量用于记录棋子连续的总数
        int num1 = 0;
        //声明变量用于记录棋子连续的总数
        int num2 = 0;
        //声明变量用于记录棋子连续的总数
        int num3 = 0;
        //声明变量用于记录棋子连续的总数
        int num4 = 0;
        //声明变量用于记录棋子连续的总数
        int num5 = 0;
        //声明变量用于记录棋子连续的总数
        int num6 = 0;
        //声明变量用于记录棋子连续的总数
        int num7 = 0;
        //声明变量用于记录棋子连续的总数
        int num8 = 0;
        //声明变量用于记录棋子连续的总数
        int num9 = 0;
        //声明winner变量，用于记录判断胜利者
        boolean winner = false;
        //使用双重for遍历行，实现判断棋子连续5个时胜利
        for (int i = 0; i < 15; i++) {
            for (int j = 0; j < 15; j++) {
                //使用if判断值不为空时校验
                if (null != theBoard[i][j]) {
                    //判断theBoard[i][j]对应的值和theBoard[i][j + 1]对应的值是否相等
                    if (theBoard[i][j].equals(theBoard[i][j + 1])) {
                        //判断judge等于true时执行一下语句块，为黑棋，白棋执行else语句块
                        if (true == judge) {
                            //判断行列对应的坐标为null或者等于白棋时，num=0；
                            if (null == theBoard[i][j] || WHTIE == theBoard[i][j]) {
                                num = 0;
                            } else {
                                //System.out.println("num的值为" + num);
                                //判断如果num=3提示黑方/白方获胜
                                if (3 == num) {
                                    System.out.println((judge ? BLACK : WHTIE) + "方获胜");
                                    //获胜时赋值true给winner
                                    winner = true;
                                    //结束循环
                                    break;
                                }
                                num++;
                            }
                        } else {
                            //判断行列对应的坐标为null或者等于黑棋时，num1=0；
                            if (null == theBoard[i][j] || BLACK == theBoard[i][j]) {
                                num1 = 0;
                            } else {
                                //System.out.println("num1的值为" + num1);
                                //判断如果num=3提示黑方/白方获胜
                                if (3 == num1) {
                                    System.out.println((judge ? BLACK : WHTIE) + "方获胜");
                                    //获胜时赋值true给winner
                                    winner = true;
                                    //结束循环
                                    break;
                                }
                                num1++;
                            }


                        }
                    }
                }
            }
        }

        //使用双重for遍历列，实现判断棋子连续5个时胜利
        for (int i = 0; i < 15; i++) {
            for (int j = 0; j < 15; j++) {
                //使用if判断值不为空时校验
                if (null != theBoard[i][j]) {
                    //if (i - 1 > 0||j-1>0){n=0}
                    //判断如果行列等于0时进行if下语句块，防止数组下标越界
                    if (0 == line || line == i || 0 == column || column == j || 0 == i || j == 0) {
                        //判断theBoard[i][j]对应的值和theBoard[i+1][j]对应的值是否相等，实现当前坐标值和当前列不变行+1对应的值进行判断
                        if (theBoard[line][column].equals(theBoard[i + 1][j])) {
                            //判断judge等于true时执行一下语句块，为黑棋，白棋执行else语句块
                            if (true == judge) {
                                //判断行列对应的坐标为null或者等于白棋时，num2=0；
                                if (null == theBoard[i][j] || WHTIE == theBoard[i][j]) {
                                    num2 = 0;
                                } else {
                                    //System.out.println("num的值为++++++++" + num2);
                                    //判断如果num2=3提示黑方/白方获胜
                                    if (3 == num2) {
                                        System.out.println((judge ? BLACK : WHTIE) + "方获胜");
                                        //获胜时赋值true给winner
                                        winner = true;
                                        //结束循环
                                        break;
                                    }
                                    num2++;
                                }
                            } else {
                                //判断行列对应的坐标为null或者等于白棋时，num3=0；
                                if (null == theBoard[i][j] || BLACK == theBoard[i][j]) {
                                    num3 = 0;
                                } else {
                                    //System.out.println("num1的值为++++++++" + num3);
                                    //判断如果num3=3提示黑方/白方获胜
                                    if (3 == num3) {
                                        System.out.println((judge ? BLACK : WHTIE) + "方获胜");
                                        //获胜时赋值true给winner
                                        winner = true;
                                        //结束循环
                                        break;
                                    }
                                    num3++;
                                }


                            }
                        }
                    } else {
                        //判断theBoard[i][j]对应的值和theBoard[i+1][j]或者theBoard[i-1][j]对应的值是否相等，实现当前坐标值和当前列不变行+1或者-1对应的值进行判断是否相等
                        if (theBoard[line][column].equals(theBoard[i + 1][j]) || theBoard[line][column].equals(theBoard[i - 1][j])) {
                            if (true == judge) {
                                //判断行列对应的坐标为null或者等于白棋时，num3=0；
                                if (null == theBoard[i][j] || WHTIE == theBoard[i][j]) {
                                    num4 = 0;
                                } else {
                                    //System.out.println("num的值为++++++++" + num4);
                                    //判断如果num4=3提示黑方/白方获胜
                                    if (3 == num4) {
                                        System.out.println((judge ? BLACK : WHTIE) + "方获胜");
                                        //获胜时赋值true给winner
                                        winner = true;
                                        break;
                                    }
                                    num4++;
                                }
                            } else {
                                //判断行列对应的坐标为null或者等于白棋时，num5=0；
                                if (null == theBoard[i][j] || BLACK == theBoard[i][j]) {
                                    num5 = 0;
                                } else {
                                    //System.out.println("num1的值为++++++++" + num5);
                                    //判断如果num5=3提示黑方/白方获胜
                                    if (3 == num5) {
                                        System.out.println((judge ? BLACK : WHTIE) + "方获胜");
                                        //获胜时赋值true给winner
                                        winner = true;
                                        break;
                                    }
                                    num5++;
                                }


                            }
                        }
                    }


                }

            }
        }


        //使用双重for遍历左上到右下，实现判断棋子连续5个时胜利
        for (int i = 0; i < 15; i++) {
            for (int j = 0; j < 15; j++) {
                //if (i == j) {
                //使用if判断值不为空时校验
                if (null != theBoard[i][j]) {
                    //判断theBoard[i][j]对应的值和theBoard[i+1][j+1]对应的值是否相等，实现当前坐标值和下一列下一行对应的值进行判断是否相等
                    if (theBoard[line][column].equals(theBoard[i + 1][j + 1])) {
                        if (true == judge) {
                            //判断行列对应的坐标为null或者等于白棋时，num6=0；
                            if (null == theBoard[i][j] || WHTIE == theBoard[i][j]) {
                                num6 = 0;
                            } else {
                                //System.out.println("num的值为>>>>>>" + num6);
                                //判断如果num6=3提示黑方/白方获胜
                                if (3 == num6) {
                                    System.out.println((judge ? BLACK : WHTIE) + "方获胜");
                                    //获胜时赋值true给winner
                                    winner = true;
                                    break;
                                }
                                num6++;
                            }
                        } else {
                            //判断行列对应的坐标为null或者等于白棋时，num7=0；
                            if (null == theBoard[i][j] || BLACK == theBoard[i][j]) {
                                num7 = 0;
                            } else {
                                //System.out.println("num1的值为>>>>>>>" + num7);
                                //判断如果num7=3提示黑方/白方获胜
                                if (3 == num7) {
                                    System.out.println((judge ? BLACK : WHTIE) + "方获胜");
                                    //获胜时赋值true给winner
                                    winner = true;
                                    break;
                                }
                                num7++;
                            }


                        }
                    }
                }

                //}
            }

        }

        //使用双重for遍历右上到左下，实现判断棋子连续5个时胜利
        for (int i = 0; i < 15; i++) {
            for (int j = 0; j < 15; j++) {
                //使用if判断值不为空时校验
                if (null != theBoard[i][j]) {
                    //判断如果行列等于0时进行if下语句块，防止数组下标越界
                    if (0 == line && i == line || 0 == column && column == j || 0 == i || 0 == j) {

                    } else {
                        //判断theBoard[i][j]对应的值和theBoard[i+1][j-1]/theBoard[i-1][j+1]对应的值是否相等，实现当前坐标值和下一列下一行对应的值进行判断是否相等
                        if (theBoard[line][column].equals(theBoard[i + 1][j - 1]) || theBoard[line][column].equals(theBoard[i - 1][j + 1])) {
                            if (true == judge) {
                                //判断行列对应的坐标为null或者等于白棋时，num8=0；
                                if (null == theBoard[i][j] || WHTIE == theBoard[i][j]) {
                                    num8 = 0;
                                } else {
                                    //System.out.println("num的值为-------" + num8);
                                    //判断如果num7=3提示黑方/白方获胜
                                    if (3 == num8) {
                                        System.out.println((judge ? BLACK : WHTIE) + "方获胜");
                                        //获胜时赋值true给winner
                                        winner = true;
                                        break;
                                    }
                                    num8++;
                                }
                            } else {
                                //判断行列对应的坐标为null或者等于白棋时，num9=0；
                                if (null == theBoard[i][j] || BLACK == theBoard[i][j]) {
                                    num9 = 0;
                                } else {
                                    //System.out.println("num1的值为-------" + num9);
                                    //判断如果num9=3提示黑方/白方获胜
                                    if (3 == num9) {
                                        System.out.println((judge ? BLACK : WHTIE) + "方获胜");
                                        //获胜时赋值true给winner
                                        winner = true;
                                        break;
                                    }
                                    num9++;
                                }


                            }
                        }
                    }


                }

            }

        }
        //返回winner值
        return winner;

    }
}
